package com.huangyi;

public class Main {
    public static void main(String[] args) {
        Solution solution = new Solution();
        Solution2 solution2 = new Solution2();

        // 测试等差数列划分
        System.out.println("=== 等差数列划分 ===");
        int[] nums1 = {1, 2, 3, 4};
        System.out.println("测试用例1: [1,2,3,4]");
        System.out.println("等差子数组个数: " + solution.numberOfArithmeticSlices(nums1)); // 预期输出: 3

        int[] nums2 = {1};
        System.out.println("\n测试用例2: [1]");
        System.out.println("等差子数组个数: " + solution.numberOfArithmeticSlices(nums2)); // 预期输出: 0

        // 测试最长湍流子数组
        System.out.println("\n=== 最长湍流子数组 ===");
        int[] arr1 = {9, 4, 2, 10, 7, 8, 8, 1, 9};
        System.out.println("测试用例1: [9,4,2,10,7,8,8,1,9]");
        System.out.println("最长湍流长度: " + solution2.maxTurbulenceSize(arr1)); // 预期输出: 5

        int[] arr2 = {4, 8, 12, 16};
        System.out.println("\n测试用例2: [4,8,12,16]");
        System.out.println("最长湍流长度: " + solution2.maxTurbulenceSize(arr2)); // 预期输出: 2

        int[] arr3 = {100};
        System.out.println("\n测试用例3: [100]");
        System.out.println("最长湍流长度: " + solution2.maxTurbulenceSize(arr3)); // 预期输出: 1
    }

    // 等差数列划分
    static class Solution {
        public int numberOfArithmeticSlices(int[] nums) {
            int n = nums.length;
            if (n < 3) return 0; // 少于3个元素无法构成等差数列

            int[] dp = new int[n]; // dp[i]: 以 nums[i] 结尾的等差子数组个数
            int result = 0;

            for (int i = 2; i < n; i++) {
                // 检查最近三个元素是否等差
                if (nums[i] - nums[i - 1] == nums[i - 1] - nums[i - 2]) {
                    // 可以扩展：继承 dp[i-1] 个 + 新增1个（最短的3元素数组）
                    dp[i] = dp[i - 1] + 1;
                }
                // 否则 dp[i] = 0（默认值）

                result += dp[i]; // 累加当前位置的贡献
            }

            return result;
        }
    }

    // 最长湍流子数组
    static class Solution2 {
        public int maxTurbulenceSize(int[] arr) {
            int n = arr.length;
            if (n == 1) return 1;

            // f[i]: 以 arr[i-1] 结尾，最后一步上升的湍流子数组长度
            // g[i]: 以 arr[i-1] 结尾，最后一步下降的湍流子数组长度
            int[] f = new int[n + 1];
            int[] g = new int[n + 1];

            f[1] = g[1] = 1;
            int result = 1;

            for (int i = 2; i <= n; i++) {
                if (arr[i - 1] == arr[i - 2]) {
                    // 相等：湍流中断
                    f[i] = g[i] = 1;
                } else if (arr[i - 1] > arr[i - 2]) {
                    // 当前上升：接在下降后面才能保持湍流
                    f[i] = g[i - 1] + 1;
                    g[i] = 1;
                } else {
                    // 当前下降：接在上升后面才能保持湍流
                    g[i] = f[i - 1] + 1;
                    f[i] = 1;
                }

                result = Math.max(result, Math.max(f[i], g[i]));
            }

            return result;
        }
    }
}